.TH std::expected::swap 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::expected::swap \- std::expected::swap

.SH Synopsis
   constexpr void swap( expected& other ) noexcept(/*see below*/);  (since C++23)

   Swaps the contents with those of other.

     * If both this->has_value() and other.has_value() are true:

     * If T is (possibly cv-qualified) void, no effects.
     * Otherwise, equivalent to using std::swap; swap(**this, *other);.
     * If both this->has_value() and other.has_value() are false, equivalent to
       using std::swap; swap(this->error(), other.error());.
     * If this->has_value() is false and other.has_value() is true, calls
       other.swap(*this).
     * If this->has_value() is true and other.has_value() is false,

     * If T is (possibly cv-qualified) void, let unex be the member that represents the
       unexpected value, equivalent to:

 std::construct_at(std::addressof(unex), std::move(other.unex));
 std::destroy_at(std::addressof(other.unex));

     * Otherwise, let val be the member that represents the expected value and unex be
       the member that represents the unexpected value, equivalent to:

 if constexpr (std::is_nothrow_move_constructible_v<E>) {
     E temp(std::move(other.unex));
     std::destroy_at(std::addressof(other.unex));
     try {
         std::construct_at(std::addressof(other.val), std::move(val));
         std::destroy_at(std::addressof(val));
         std::construct_at(std::addressof(unex), std::move(temp));
     } catch(...) {
         std::construct_at(std::addressof(other.unex), std::move(temp));
         throw;
     }
 } else {
     T temp(std::move(val));
     std::destroy_at(std::addressof(val));
     try {
         std::construct_at(std::addressof(unex), std::move(other.unex));
         std::destroy_at(std::addressof(other.unex));
         std::construct_at(std::addressof(other.val), std::move(temp));
     } catch(...) {
         std::construct_at(std::addressof(val), std::move(temp));
         throw;
     }
 }

     * In either case, if no exception was thrown, after swap, this->has_value() is
       false, and other.has_value() is true.

   This function participates in overload resolution only if

     * either T is (possibly cv-qualified) void, or std::is_swappable_v<T> is true, and
     * std::is_swappable_v<E> is true, and
     * either T is (possibly cv-qualified) void, or std::is_move_constructible_v<T> is
       true, and
     * std::is_move_constructible_v<E> is true, and
     * at least one of the following is true:
          * T is (possibly cv-qualified) void
          * std::is_nothrow_move_constructible_v<T>
          * std::is_nothrow_move_constructible_v<E>

.SH Parameters

   other - the optional object to exchange the contents with

.SH Return value

   \fI(none)\fP

.SH Exceptions

   If T is (possibly cv-qualified) void,
   noexcept specification:
   noexcept(

       std::is_nothrow_move_constructible_v<E> && std::is_nothrow_swappable_v<E>

   )
   Otherwise,
   noexcept specification:
   noexcept(

       std::is_nothrow_move_constructible_v<T> && std::is_nothrow_swappable_v<T> &&
       std::is_nothrow_move_constructible_v<E> && std::is_nothrow_swappable_v<E>

   )

   In the case of thrown exception, the states of the contained values of *this and
   other are determined by the exception safety guarantees of swap or T's and E's move
   constructor, whichever is called. For both *this and other, if the object contained
   an expected value, it is left containing an expected value, and the other way round.

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   swap(std::expected) specializes the std::swap algorithm
   (C++23)             \fI(function)\fP

.SH Categories:
     * conditionally noexcept
     * Todo no example
